#ifndef USE_MIPS_ASSEMBLY
#define USE_MIPS_ASSEMBLY
#include <mips/regdef.h>
#include <sys/syscall.h>

	.text
	.abicalls
	.align 2
	.globl	wc
	.ent 	wc
wc:
	#creacion del stack
	.frame  $fp, 64, ra
	.set 	noreorder
	.cpload t9
	.set	reorder
	subu sp, sp, 64
	.cprestore 48
	sw gp, 48(sp)
	sw $fp, 52(sp)
	sw ra, 56(sp)

	move $fp,sp

	#Recupero el viejo fp
	lw t0, 52(sp)	#t0 es el fp del caller
	#lw t2, 52(t0) 	#56+t0 es la dire del contador de palabra
	#lw t3, 56(t0)	#60+t0 la del byte
	#lw t4, 60(t0)	#64+t0 la de linea.
	#no lo uso para nada esto, solo para testear

	li t1, 0
	addu t1, t0, 52 #t1 contiene la dire de cont palabra
	li t2, 0
	addu t2, t0, 56 #t2 contiene la dire de cont byte
	li t3, 0
	addu t3, t0, 60 # t3 contiene la dire de linea

	move s5, t1 #guardo en s5, s6 y s7 las direcciones
	move s6, t2
	move s7, t3
	# guardo argumentos

test2:
	sw a0, 64($fp) #fd_input
	sw a1, 68($fp) #cont_pal_tot
	sw a2, 72($fp) #cont_byte_tot
	sw a3, 76($fp) #cont_linea_tot

	li t0, 0
	sw t0, 20($fp) #cont_palabra = 0
	li t1, 0
	sw t1, 24($fp) #cont_byte = 0
	li t2, 0
	sw t2, 28($fp) #cont_linea = 0
	li t3, 1
	sb t3, 32($fp) #anterior_fue_espacio_o_newline = 1

	sb zero, 36($fp) #byte
	sw zero, 40($fp) #leido

	# preparo el read
	lw a0, 64($fp) #fd_input
	li a1, 36
	addu a1, a1, $fp #cargo la direcion de byte
	li a2, 1 #sizeof char
	li v0, SYS_read
	syscall

	sw v0, 40($fp) #leido = read()

loop:
	lw t0, 40($fp) #leido
	beqz t0, fin_while #salto si leido igual a cero (while)

	# preparo el count
	lb t1, 36($fp) #cargo byte
	sb t1, 36($fp) #guardo byte
	# cargo argumentos: byte, cont_palabra, cont_byte, cont_linea y anterior_fue_espacio_o_newline
	move a0, t1
	li a1, 20
	addu a1, a1, $fp #cargo la direccion de cont_palabra
	li a2, 24
	addu a2, a2, $fp #cargo la direccion de cont_byte
	li a3, 28
	addu a3, a3, $fp #cargo la direccion de cont_linea
	li s0, 32
	addu s0, s0, $fp #cargo la direccion de anterior_fue_espacio_o_newline

	la	t9, count #llamar a count
	jal	ra, t9
	#guardo los contadores
	sw s1, 20($fp) #guardo cont_palabra
	sw s2, 24($fp) #guardo cont_byte
	sw s3, 28($fp) #guardo cont_linea
	sw s0, 32($fp) #guardo anterior

	#argumento para read

	lw a0, 64($fp) #fd_input
	li a1, 36
	addu a1, a1, $fp #cargo la direcion de byte
	li a2, 1 #sizeof char
	li v0, SYS_read
	syscall

	sw v0, 40($fp) #leido = read()
	b loop

fin_while:

	lw t0, 20($fp) #cargo cont_palabra
	lw t1, 24($fp) #cargo cont_byte
	lw t2, 28($fp) #cargo cont_linea

	lw a1, 68($fp) #cargo la direccion de cont_pal_tot
	lw a2, 72($fp) #cargo la direccion de cont_byte_tot
	lw a3, 76($fp) #cargo la direccion de cont_linea_tot

	lw t5 ,(a1) #cargo el valor de cont_pal_tot
	lw t6 ,(a2) #cargo el valor de cont_byte_tot
	lw t7 ,(a3)	 #cargo el valor de cont_linea_tot

test3:
	addu t5, t5, t0 #cont_pal_tot += cont_palabra
	addu t6, t6, t1 #cont_byte_tot += cont_byte
	addu t7, t7, t2 #cont_linea_tot += cont_linea

	sw t5, (a1) #guardo el valor de cont_pal_tot en la direccion de cont_pal_tot
	sw t6, (a2) #guardo el valor de cont_byte_tot en la direccion de cont_byte_tot
	sw t7, (a3) #guardo el valor de cont_linea_tot en la direccion de cont_linea_tot
test:
	#printf
	#li a0, 1		 #stdout
	#la a1, palabras	# print("palabras: ");
	#li a2, 11 # cant bytes
	#li v0, SYS_write # syscall de netbsd
#	syscall
#
	#li a0, 1		 #stdout
	#move a1, t0	# print(cont_palabra);
	#li a2, 32 # cant bytes
	#li v0, SYS_writev # syscall de netbsd
	#syscall
	sw t0, (s5) #palabra
	#li a0, 1 		#stdout
	#la a1, lineas	# print("lineas: ");
	#li a2, 9 #cant bytes
	#li v0, SYS_write
	#syscall
#	li a0, 1 		#stdout
	#lw a1, 28($fp)	# print(cont_linea);
	#li a2, 4
	#li v0, SYS_write
	#syscall
	sw t1, (s6) #byte
	#li a0, 1 		#stdout
	#la a1, bytes	# print("bytes: ");
	#li a2, 8
	#li v0, SYS_write
	#syscall
	#li a0, 1 		#stdout
#	lw a1, 24($fp)	# print(cont_byte);
	#li a2, 4
	#li v0, SYS_write
	#syscall
	sw t2, (s7) #linea

	move sp, $fp
	lw ra, 56(sp) #recupero ra
	lw $fp, 52(sp) #recupero fp
	lw gp, 48(sp) #recupero gp
	addu sp,sp,64
	jr ra
	.end wc

	.ent count
count:
	#creacion del stack
	.frame $fp, 32, ra #gp, fp
	.set	noreorder
	.cpload t9
	.set	reorder
	subu sp, sp, 32
	.cprestore 24
	sw gp, 24(sp)
	sw $fp, 28(sp)
	move $fp, sp

	#guardo argumentos

	move t0, a0 #char
	lw t1, (a1) #cont_palabra
	lw t2, (a2) #cont_byte
	lw t3, (a3) #count_linea
	lb t4, (s0) #falta guardar argumento 5, el anterior

	addi t2, t2 , 1 #cont_byte += 1

	li t5, 0xa #cargo salto de linea

	bne t0, t5, if_anterior #salto si no se trata de salto de linea

	#continuo con el if
	addi t3, t3, 1 #count_linea += 1

if_anterior:
	beqz t4, if_c_vacio # salto if(*anterior == 0)

c_vacio:

	li t6, 0x20 #cargo vacio
	bne t0, t6, c_salto_de_linea #salto si no se trata de vacio

	#continuo en el if
	li t4, 1 #anterior = 1
	b fin

if_c_vacio:

	li t6, 0x20 #cargo vacio
	bne t0, t6, if_c_salto_de_linea #salto si no se trata de vacio

	#continuo en el if
	addi t1, t1, 1 #cont_palabra += 1
	b c_vacio

anterior_0:
	li t4, 0 #anterior = 0
	b fin

if_c_salto_de_linea:

	li t5, 0xa #cargo salto de linea
	bne t0, t5, c_vacio #salto si no se trata de salto de linea

	#continuo en el if
	addi t1, t1, 1 #cont_palabra += 1
	b c_vacio

c_salto_de_linea:

	li t5, 0xa #cargo salto de linea
	bne t0, t5, anterior_0 #salto si no se trata de salto de linea

	#continuo en el if
	li t4, 1 #anterior = 1

	b fin
fin:
	move s0, t4 #anterior
	move s1, t1 #cont_palabra
	move s2, t2 #cont_byte
	move s3, t3 #cont_linea

	move sp, $fp
	lw $fp, 28(sp)
	lw gp, 24(sp) #
	addu sp, sp, 32
	jr ra
	.end count

palabras:	.asciiz "palabras: \n"
lineas:		.asciiz "lineas: \n"
bytes:		.asciiz "bytes: \n"

#endif


